const {removeAuthData} = require('../../../utils/storageUtil');
const { isLogin, getUserId } = require('../../../utils/userManager');
const { http } = require('../../../utils/http');
Page({
    data: {
        // 切换开关设置
        nightMode: true,
        autoNext: true,
        autoSave: true,
        // 数值设置
        fontSize: 20,
        textAlign: '智能',
        //登陆状态
        loginStatus: "",
        // 字体大小选项 (最多6个选项)
        fontSizeOptions: [16, 18, 20, 22, 24, 26],
        // 对齐方式选项
        alignOptions: ['智能', '左对齐', '居中', '右对齐'],
        // 配置是否已修改（用于判断是否需要保存）
        configModified: false,
        // 原始配置（用于比较是否有变化）
        originalConfig: null
    },
    onShow() {
        // 每次页面显示时重新检查登录状态
        this.setData({
             loginStatus: isLogin()
        });
        
        // 如果已登录，获取用户配置
        if (isLogin()) {
            this.loadUserConfig();
        }
    },
    
    /**
     * 页面隐藏时自动保存配置
     */
    onHide() {
        console.log('页面隐藏，检查是否需要保存配置');
        this.autoSaveConfig();
    },
    
    /**
     * 页面卸载时自动保存配置
     */
    onUnload() {
        console.log('页面卸载，检查是否需要保存配置');
        this.autoSaveConfig();
    },
    
    /**
     * 加载用户配置
     */
    async loadUserConfig() {
        try {
            wx.showLoading({
                title: '加载配置中...',
                mask: true
            });
            
            // 获取用户ID
            const userId = getUserId();
            if (!userId) {
                throw new Error('用户未登录或用户ID不存在');
            }
            
            // 直接调用HTTP请求获取配置
            const response = await http.get('/ssh/config/list', { userId });
            let config;
            if (response && response.rows && response.rows.length > 0) {
                config = response.rows[0]; // 返回第一个配置对象
            } else {
                // 如果没有配置，返回默认配置
                config = {
                    id: null,
                    userId: userId,
                    nightMode: 0,
                    autoNext: 1,
                    autoSave: 0,
                    fontSize: 18,
                    textAlign: "左对齐"
                };
            }
            
            // 更新页面数据
            this.setData({
                nightMode: config.nightMode === 1,
                autoNext: config.autoNext === 1,
                autoSave: config.autoSave === 1,
                fontSize: config.fontSize || 20,
                textAlign: config.textAlign || '智能',
                // 保存原始配置用于比较
                originalConfig: {
                    nightMode: config.nightMode === 1,
                    autoNext: config.autoNext === 1,
                    autoSave: config.autoSave === 1,
                    fontSize: config.fontSize || 20,
                    textAlign: config.textAlign || '智能'
                },
                configModified: false
            });
            
            console.log('用户配置加载成功:', config);
            
        } catch (error) {
            console.error('加载用户配置失败:', error);
            wx.showToast({
                title: '配置加载失败',
                icon: 'none',
                duration: 2000
            });
        } finally {
            wx.hideLoading();
        }
    },
    
    /**
     * 检查配置是否有变化
     */
    checkConfigModified() {
        const currentConfig = {
            nightMode: this.data.nightMode,
            autoNext: this.data.autoNext,
            autoSave: this.data.autoSave,
            fontSize: this.data.fontSize,
            textAlign: this.data.textAlign
        };
        
        const originalConfig = this.data.originalConfig;
        if (!originalConfig) return false;
        
        return JSON.stringify(currentConfig) !== JSON.stringify(originalConfig);
    },
    
    /**
     * 标记配置已修改
     */
    markConfigModified() {
        this.setData({
            configModified: true
        });
        console.log('配置已标记为修改状态');
    },
    
    /**
     * 自动保存配置（在页面隐藏或卸载时调用）
     */
    async autoSaveConfig() {
        // 检查配置是否有变化
        if (this.checkConfigModified()) {
            console.log('检测到配置变化，自动保存配置');
            await this.saveUserConfig();
        } else {
            console.log('配置无变化，无需保存');
        }
    },
    
    /**
     * 保存用户配置到后端
     */
    async saveUserConfig() {
        try {
            // 检查登录状态
            if (!isLogin()) {
                console.log('用户未登录，跳过配置保存');
                return;
            }
            // 检查配置是否有变化
            if (!this.checkConfigModified()) {
                console.log('配置无变化，跳过保存');
                return;
            }
            // 获取用户ID
            const userId = getUserId();
            if (!userId) {
                throw new Error('用户未登录或用户ID不存在');
            }
            // 构建配置对象
            const config = {
                nightMode: this.data.nightMode ? 1 : 0,
                autoNext: this.data.autoNext ? 1 : 0,
                autoSave: this.data.autoSave ? 1 : 0,
                fontSize: this.data.fontSize,
                textAlign: this.data.textAlign,
                userId: userId
            };
            // 调用新的接口保存配置
            await http.put('/ssh/config', config);
            // 更新原始配置，重置修改标记
            this.setData({
                originalConfig: {
                    nightMode: this.data.nightMode,
                    autoNext: this.data.autoNext,
                    autoSave: this.data.autoSave,
                    fontSize: this.data.fontSize,
                    textAlign: this.data.textAlign
                },
                configModified: false
            });
            
        } catch (error) {
            console.error('保存用户配置失败:', error);
            wx.showToast({
                title: '配置保存失败',
                icon: 'none',
                duration: 2000
            });
        }
    },
    
    // 夜间模式切换
    onNightModeChange(e) {
        this.setData({
            nightMode: e.detail
        });
        console.log('夜间模式:', e.detail);
        
        // 标记配置已修改
        this.markConfigModified();
    },

    // 自动下一题切换
    onAutoNextChange(e) {
        this.setData({
            autoNext: e.detail
        });
        console.log('自动下一题:', e.detail);
        
        // 标记配置已修改
        this.markConfigModified();
    },

    // 自动保存答案切换
    onAutoSaveChange(e) {
        this.setData({
            autoSave: e.detail
        });
        console.log('自动保存答案:', e.detail);
        
        // 标记配置已修改
        this.markConfigModified();
    },

    // 字体大小设置
    onFontSizeTap() {
        // 转换为字符串数组，确保显示正常
        const itemList = this.data.fontSizeOptions.map(item => item.toString());
        wx.showActionSheet({
            itemList: itemList,
            success: (res) => {
                const selectedSize = this.data.fontSizeOptions[res.tapIndex];
                this.setData({
                    fontSize: selectedSize
                });
                console.log('字体大小设置为:', selectedSize);
                
                // 标记配置已修改
                this.markConfigModified();
                
                // 显示成功提示
                wx.showToast({
                    title: '设置成功',
                    icon: 'success',
                    duration: 1000
                });
            }
        });
    },

    // 文本对齐方式设置
    onTextAlignTap() {
        console.log('文本对齐方式点击事件触发');
        wx.showActionSheet({
            itemList: this.data.alignOptions,
            success: (res) => {
                const selectedAlign = this.data.alignOptions[res.tapIndex];
                this.setData({
                    textAlign: selectedAlign
                });
                console.log('文本对齐方式设置为:', selectedAlign);
                
                // 标记配置已修改
                this.markConfigModified();
                
                // 显示成功提示
                wx.showToast({
                    title: '设置成功',
                    icon: 'success',
                    duration: 1000
                });
            }
        });
    },

    // 清理做题页面缓存
    onClearCache() {
        wx.showModal({
            title: '确认清理',
            content: '确定要清理做题页面缓存吗？',
            success: (res) => {
                if (res.confirm) {
                    wx.showToast({
                        title: '缓存清理成功',
                        icon: 'success'
                    });
                    console.log('清理做题页面缓存');
                }
            }
        });
    },

    // 清空题库做题记录
    onClearRecords() {
        wx.showModal({
            title: '确认清空',
            content: '确定要清空题库做题记录吗？此操作不可恢复！',
            success: (res) => {
                if (res.confirm) {
                    wx.showToast({
                        title: '记录清空成功',
                        icon: 'success'
                    });
                    console.log('清空题库做题记录');
                }
            }
        });
    },
    // 退出登录
    onLoginOut() {
        // 检查是否登录
        if (!this.data.loginStatus) {
            wx.showToast({
                title: '您未登录',
                icon: 'none',
                duration: 1000
            });
            return;
        }
        wx.showModal({
            title: '确认退出',
            content: '确定要退出登录吗？退出后将清除您的登录信息。',
            success: (res) => {
                if (res.confirm) {
                    // 显示加载提示
                    wx.showLoading({
                        title: '正在退出...',
                        mask: true
                    });

                    // 停止token过期检测服务
                    this.stopTokenCheckService();
                    
                    // 使用utils中的removeAuthData函数清除所有认证数据
                    try {
                        removeAuthData();
                        console.log('已清除用户登录信息和token');

                        // 清除全局数据中的用户信息
                        const app = getApp();
                        if (app.globalData) {
                            app.globalData.userInfo = null;
                            app.globalData.token = null;
                        }
                        // 隐藏加载提示
                        wx.hideLoading();
                        // 显示退出成功提示
                        wx.showToast({
                            title: '已退出登录',
                            icon: 'success',
                            duration: 1500
                        });
                        console.log('退出登录成功');
                        // 延迟跳转到首页，确保提示显示完整
                        setTimeout(() => {
                            // 跳转到首页
                            wx.reLaunch({
                                url: '/pages/index/index',
                                success: () => {
                                    console.log('成功跳转到首页');
                                },
                                fail: (err) => {
                                    console.error('跳转到首页失败:', err);
                                    // 如果跳转失败，尝试使用switchTab
                                    wx.switchTab({
                                        url: '/pages/index/index'
                                    });
                                }
                            });
                        }, 1500);
                    } catch (e) {
                        // 隐藏加载提示
                        wx.hideLoading();
                        console.error('清除认证数据失败:', e);
                        // 显示错误提示
                        wx.showToast({
                            title: '退出登录失败',
                            icon: 'none',
                            duration: 2000
                        });
                    }
                }
            }
        });
    },
    onBack() {
        wx.navigateBack()
    },

    /**
     * 停止token过期检测服务
     */
    stopTokenCheckService() {
        try {
            const { tokenService } = require('../../../utils/tokenService.js');
            if (tokenService) {
                console.log('用户主动登出，停止token过期检测服务');
                tokenService.stopTokenCheck();
            }
        } catch (error) {
            console.error('停止token检测服务失败:', error);
        }
    }
});